home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Programming / Python1.4_Source / Parser / parser.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-24  |  9.4 KB  |  429 lines
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its
  8. documentation for any purpose and without fee is hereby granted,
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI or Corporation for National Research Initiatives or
  13. CNRI not be used in advertising or publicity pertaining to
  14. distribution of the software without specific, written prior
  15. permission.
  16.  
  17. While CWI is the initial source for this software, a modified version
  18. is made available by the Corporation for National Research Initiatives
  19. (CNRI) at the Internet address ftp://ftp.python.org.
  20.  
  21. STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22. REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23. MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24. CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26. PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27. TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28. PERFORMANCE OF THIS SOFTWARE.
  29.  
  30. ******************************************************************/
  31.  
  32. /* Parser implementation */
  33.  
  34. /* For a description, see the comments at end of this file */
  35.  
  36. /* XXX To do: error recovery */
  37.  
  38. #include "pgenheaders.h"
  39. #include "assert.h"
  40. #include "token.h"
  41. #include "grammar.h"
  42. #include "node.h"
  43. #include "parser.h"
  44. #include "errcode.h"
  45.  
  46.  
  47. #ifdef DEBUG
  48. extern int debugging;
  49. #define D(x) if (!debugging); else x
  50. #else
  51. #define D(x)
  52. #endif
  53.  
  54.  
  55. /* STACK DATA TYPE */
  56.  
  57. static void s_reset PROTO((stack *));
  58.  
  59. static void
  60. s_reset(s)
  61.     stack *s;
  62. {
  63.     s->s_top = &s->s_base[MAXSTACK];
  64. }
  65.  
  66. #define s_empty(s) ((s)->s_top == &(s)->s_base[MAXSTACK])
  67.  
  68. static int s_push PROTO((stack *, dfa *, node *));
  69.  
  70. static int
  71. s_push(s, d, parent)
  72.     register stack *s;
  73.     dfa *d;
  74.     node *parent;
  75. {
  76.     register stackentry *top;
  77.     if (s->s_top == s->s_base) {
  78.         fprintf(stderr, "s_push: parser stack overflow\n");
  79.         return -1;
  80.     }
  81.     top = --s->s_top;
  82.     top->s_dfa = d;
  83.     top->s_parent = parent;
  84.     top->s_state = 0;
  85.     return 0;
  86. }
  87.  
  88. #ifdef DEBUG
  89.  
  90. static void s_pop PROTO((stack *));
  91.  
  92. static void
  93. s_pop(s)
  94.     register stack *s;
  95. {
  96.     if (s_empty(s))
  97.         fatal("s_pop: parser stack underflow -- FATAL");
  98.     s->s_top++;
  99. }
  100.  
  101. #else /* !DEBUG */
  102.  
  103. #define s_pop(s) (s)->s_top++
  104.  
  105. #endif
  106.  
  107.  
  108. /* PARSER CREATION */
  109.  
  110. parser_state *
  111. newparser(g, start)
  112.     grammar *g;
  113.     int start;
  114. {
  115.     parser_state *ps;
  116.     
  117.     if (!g->g_accel)
  118.         addaccelerators(g);
  119.     ps = NEW(parser_state, 1);
  120.     if (ps == NULL)
  121.         return NULL;
  122.     ps->p_grammar = g;
  123.     ps->p_tree = newtree(start);
  124.     if (ps->p_tree == NULL) {
  125.         DEL(ps);
  126.         return NULL;
  127.     }
  128.     s_reset(&ps->p_stack);
  129.     (void) s_push(&ps->p_stack, finddfa(g, start), ps->p_tree);
  130.     return ps;
  131. }
  132.  
  133. void
  134. delparser(ps)
  135.     parser_state *ps;
  136. {
  137.     /* NB If you want to save the parse tree,
  138.        you must set p_tree to NULL before calling delparser! */
  139.     freetree(ps->p_tree);
  140.     DEL(ps);
  141. }
  142.  
  143.  
  144. /* PARSER STACK OPERATIONS */
  145.  
  146. static int shift PROTO((stack *, int, char *, int, int));
  147.  
  148. static int
  149. shift(s, type, str, newstate, lineno)
  150.     register stack *s;
  151.     int type;
  152.     char *str;
  153.     int newstate;
  154.     int lineno;
  155. {
  156.     assert(!s_empty(s));
  157.     if (addchild(s->s_top->s_parent, type, str, lineno) == NULL) {
  158.         fprintf(stderr, "shift: no mem in addchild\n");
  159.         return -1;
  160.     }
  161.     s->s_top->s_state = newstate;
  162.     return 0;
  163. }
  164.  
  165. static int push PROTO((stack *, int, dfa *, int, int));
  166.  
  167. static int
  168. push(s, type, d, newstate, lineno)
  169.     register stack *s;
  170.     int type;
  171.     dfa *d;
  172.     int newstate;
  173.     int lineno;
  174. {
  175.     register node *n;
  176.     n = s->s_top->s_parent;
  177.     assert(!s_empty(s));
  178.     if (addchild(n, type, (char *)NULL, lineno) == NULL) {
  179.         fprintf(stderr, "push: no mem in addchild\n");
  180.         return -1;
  181.     }
  182.     s->s_top->s_state = newstate;
  183.     return s_push(s, d, CHILD(n, NCH(n)-1));
  184. }
  185.  
  186.  
  187. /* PARSER PROPER */
  188.  
  189. static int classify PROTO((grammar *, int, char *));
  190.  
  191. static int
  192. classify(g, type, str)
  193.     grammar *g;
  194.     register int type;
  195.     char *str;
  196. {
  197.     register int n = g->g_ll.ll_nlabels;
  198.     
  199.     if (type == NAME) {
  200.         register char *s = str;
  201.         register label *l = g->g_ll.ll_label;
  202.         register int i;
  203.         for (i = n; i > 0; i--, l++) {
  204.             if (l->lb_type == NAME && l->lb_str != NULL &&
  205.                     l->lb_str[0] == s[0] &&
  206.                     strcmp(l->lb_str, s) == 0) {
  207.                 D(printf("It's a keyword\n"));
  208.                 return n - i;
  209.             }
  210.         }
  211.     }
  212.     
  213.     {
  214.         register label *l = g->g_ll.ll_label;
  215.         register int i;
  216.         for (i = n; i > 0; i--, l++) {
  217.             if (l->lb_type == type && l->lb_str == NULL) {
  218.                 D(printf("It's a token we know\n"));
  219.                 return n - i;
  220.             }
  221.         }
  222.     }
  223.     
  224.     D(printf("Illegal token\n"));
  225.     return -1;
  226. }
  227.  
  228. int
  229. addtoken(ps, type, str, lineno)
  230.     register parser_state *ps;
  231.     register int type;
  232.     char *str;
  233.     int lineno;
  234. {
  235.     register int ilabel;
  236.     
  237.     D(printf("Token %s/'%s' ... ", tok_name[type], str));
  238.     
  239.     /* Find out which label this token is */
  240.     ilabel = classify(ps->p_grammar, type, str);
  241.     if (ilabel < 0)
  242.         return E_SYNTAX;
  243.     
  244.     /* Loop until the token is shifted or an error occurred */
  245.     for (;;) {
  246.         /* Fetch the current dfa and state */
  247.         register dfa *d = ps->p_stack.s_top->s_dfa;
  248.         register state *s = &d->d_state[ps->p_stack.s_top->s_state];
  249.         
  250.         D(printf(" DFA '%s', state %d:",
  251.             d->d_name, ps->p_stack.s_top->s_state));
  252.         
  253.         /* Check accelerator */
  254.         if (s->s_lower <= ilabel && ilabel < s->s_upper) {
  255.             register int x = s->s_accel[ilabel - s->s_lower];
  256.             if (x != -1) {
  257.                 if (x & (1<<7)) {
  258.                     /* Push non-terminal */
  259.                     int nt = (x >> 8) + NT_OFFSET;
  260.                     int arrow = x & ((1<<7)-1);
  261.                     dfa *d1 = finddfa(ps->p_grammar, nt);
  262.                     if (push(&ps->p_stack, nt, d1,
  263.                         arrow, lineno) < 0) {
  264.                         D(printf(" MemError: push.\n"));
  265.                         return E_NOMEM;
  266.                     }
  267.                     D(printf(" Push ...\n"));
  268.                     continue;
  269.                 }
  270.                 
  271.                 /* Shift the token */
  272.                 if (shift(&ps->p_stack, type, str,
  273.                         x, lineno) < 0) {
  274.                     D(printf(" MemError: shift.\n"));
  275.                     return E_NOMEM;
  276.                 }
  277.                 D(printf(" Shift.\n"));
  278.                 /* Pop while we are in an accept-only state */
  279.                 while (s = &d->d_state
  280.                         [ps->p_stack.s_top->s_state],
  281.                     s->s_accept && s->s_narcs == 1) {
  282.                     D(printf("  Direct pop.\n"));
  283.                     s_pop(&ps->p_stack);
  284.                     if (s_empty(&ps->p_stack)) {
  285.                         D(printf("  ACCEPT.\n"));
  286.                         return E_DONE;
  287.                     }
  288.                     d = ps->p_stack.s_top->s_dfa;
  289.                 }
  290.                 return E_OK;
  291.             }
  292.         }
  293.         
  294.         if (s->s_accept) {
  295.             /* Pop this dfa and try again */
  296.             s_pop(&ps->p_stack);
  297.             D(printf(" Pop ...\n"));
  298.             if (s_empty(&ps->p_stack)) {
  299.                 D(printf(" Error: bottom of stack.\n"));
  300.                 return E_SYNTAX;
  301.             }
  302.             continue;
  303.         }
  304.         
  305.         /* Stuck, report syntax error */
  306.         D(printf(" Error.\n"));
  307.         return E_SYNTAX;
  308.     }
  309. }
  310.  
  311.  
  312. #ifdef DEBUG
  313.  
  314. /* DEBUG OUTPUT */
  315.  
  316. void
  317. dumptree(g, n)
  318.     grammar *g;
  319.     node *n;
  320. {
  321.     int i;
  322.     
  323.     if (n == NULL)
  324.         printf("NIL");
  325.     else {
  326.         label l;
  327.         l.lb_type = TYPE(n);
  328.         l.lb_str = STR(n);
  329.         printf("%s", labelrepr(&l));
  330.         if (ISNONTERMINAL(TYPE(n))) {
  331.             printf("(");
  332.             for (i = 0; i < NCH(n); i++) {
  333.                 if (i > 0)
  334.                     printf(",");
  335.                 dumptree(g, CHILD(n, i));
  336.             }
  337.             printf(")");
  338.         }
  339.     }
  340. }
  341.  
  342. void
  343. showtree(g, n)
  344.     grammar *g;
  345.     node *n;
  346. {
  347.     int i;
  348.     
  349.     if (n == NULL)
  350.         return;
  351.     if (ISNONTERMINAL(TYPE(n))) {
  352.         for (i = 0; i < NCH(n); i++)
  353.             showtree(g, CHILD(n, i));
  354.     }
  355.     else if (ISTERMINAL(TYPE(n))) {
  356.         printf("%s", tok_name[TYPE(n)]);
  357.         if (TYPE(n) == NUMBER || TYPE(n) == NAME)
  358.             printf("(%s)", STR(n));
  359.         printf(" ");
  360.     }
  361.     else
  362.         printf("? ");
  363. }
  364.  
  365. void
  366. printtree(ps)
  367.     parser_state *ps;
  368. {
  369.     if (debugging) {
  370.         printf("Parse tree:\n");
  371.         dumptree(ps->p_grammar, ps->p_tree);
  372.         printf("\n");
  373.         printf("Tokens:\n");
  374.         showtree(ps->p_grammar, ps->p_tree);
  375.         printf("\n");
  376.     }
  377.     printf("Listing:\n");
  378.     listtree(ps->p_tree);
  379.     printf("\n");
  380. }
  381.  
  382. #endif /* DEBUG */
  383.  
  384. /*
  385.  
  386. Description
  387. -----------
  388.  
  389. The parser's interface is different than usual: the function addtoken()
  390. must be called for each token in the input.  This makes it possible to
  391. turn it into an incremental parsing system later.  The parsing system
  392. constructs a parse tree as it goes.
  393.  
  394. A parsing rule is represented as a Deterministic Finite-state Automaton
  395. (DFA).  A node in a DFA represents a state of the parser; an arc represents
  396. a transition.  Transitions are either labeled with terminal symbols or
  397. with non-terminals.  When the parser decides to follow an arc labeled
  398. with a non-terminal, it is invoked recursively with the DFA representing
  399. the parsing rule for that as its initial state; when that DFA accepts,
  400. the parser that invoked it continues.  The parse tree constructed by the
  401. recursively called parser is inserted as a child in the current parse tree.
  402.  
  403. The DFA's can be constructed automatically from a more conventional
  404. language description.  An extended LL(1) grammar (ELL(1)) is suitable.
  405. Certain restrictions make the parser's life easier: rules that can produce
  406. the empty string should be outlawed (there are other ways to put loops
  407. or optional parts in the language).  To avoid the need to construct
  408. FIRST sets, we can require that all but the last alternative of a rule
  409. (really: arc going out of a DFA's state) must begin with a terminal
  410. symbol.
  411.  
  412. As an example, consider this grammar:
  413.  
  414. expr:    term (OP term)*
  415. term:    CONSTANT | '(' expr ')'
  416.  
  417. The DFA corresponding to the rule for expr is:
  418.  
  419. ------->.---term-->.------->
  420.     ^          |
  421.     |          |
  422.     \----OP----/
  423.  
  424. The parse tree generated for the input a+b is:
  425.  
  426. (expr: (term: (NAME: a)), (OP: +), (term: (NAME: b)))
  427.  
  428. */
  429.